perm filename TRACES[AM,DBL]1 blob
sn#372419 filedate 1978-08-08 generic text, type T, neo UTF8
.ASEC(Traces of AM in Action)
.TRACES: ASECNUM ;
.UNADULT: SSECNUM;
Here is the way that the AM program begins. The human user's typing
will appear in italics.
.ONCE TURN ON "{⎇"
The careful reader will notice several small anomalies in this
transcript:
For one thing, the
task numbering here is not precisely the same as in the rest of this
document. A task is called a "Cand", and the agenda is called
"CANDS". Only some of the reasons are printed out, and they are not
as "chatty" as the reasons in. e.g., Chapter {[2]EXAM1⎇'s example
trace. The user has asked AM to type out the top three tasks on the
agenda at each "cycle". In a better hardware environment, the user
could dynamically watch the top hundred tasks bubbling around on one
side of a CRT screen. To interrupt AM, the user types CONTROL-I.
At that moment he has a very limited syntax of
questions he may ask.
See (αα) below (page {[3]ALPP⎇).
An approximate level of familiarity of the user with the AM program
is maintained by AM, as a numeric variable. Initially, its value is
determined by the number of times the human user has used AM in the
past.$$ I shall resist the temptation to call this a simple "user
model", even in a footnote. $ It gradually changes in value as a
single session proceeds. Many print statements use this variable to
determine the necessary level of detail to type.
.if false then start;
For example,
contrast
the line pointed to by an arrow labelled
⊗2(β)⊗* below with the line labelled
⊗2(ε)⊗*. In between, the variable increased to
the point where a detailed message was thought to be superfluous.
.end;
The level of detail needed for clarity should not be confused with
the level of verbosity of output that is desired. Should the user see
every function call, or the results of each task, or just monitor the
overall character of what AM is doing? A separate variable is
maintained for this verbosity indication. Finally, another partially
independent dimension is the amount of control the user wishes to
have on AM. Must he approve each move AM makes, occasionally redirect
AM, be able to ask questions? Another variable indicates the level of
user control in effect at the moment.
.BEGIN NOFILL INDENT 0 SELECT 3; PREFACE 0; TURN OFF "{⎇→←"
Entering AM's main loop now.
No Cand on CANDS is good enuf.
Do-thresh reduced from 500 to 333
Must find new candidates and merge them into CANDS.
The top 3 Cands are:
1: Fill in some examples of Set-struc-intersect
2: Fill in some examples of Set-struc-join
3: Fill in some examples of Coalesce
I choose first Cand. OK? ⊗4yes.⊗*
The reason for considering this Cand is: (We have no examples
for SET-STRUC-INTERSECT yet)
Beginning 1st cycle.
Failed. Tried to fill in new examples of SET-STRUC-INTERSECT.
⊗6<At this moment, the user hit control-I and interrupted AM.>⊗*
.ALPP: PAGE; ONCE TURN ON "→";
?: (W, I, E, M, N, ?, Q) ⊗4?⊗* →⊗8←αααα⊗*⊗2(αα)⊗3
Here are more detailed explanations of your options:
W Why: AM gives Ed the explanation behind its last printed
message.
I Interest: Ed can modify the interest ratings of concepts and
Candidates.
E Evaluate: Ed types in an expression and AM runs EVAL on it.
M Message: What was the last message that AM did NOT type out
because the verbosity was too low?
N Name: Rename some concept to whatever you want to call it.
Q Quit: resume execution.
In general, AM will automatically resume execution after answering one
query. You must hit α↑I again to interrupt.
?: ⊗4W⊗*
Why: (No examples of SET-STRUC-INTERSECT were found; there
is no reason to even consider specializing it further)
This Cand used 11.159 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Set-struc
2: Fill in some examples of Coalesce
3: Fill in some examples of Nonempty-struc
I choose first Cand. OK? ⊗4yes.⊗*
The 2 reasons for considering this Cand are:
(Active-exs specifically asked for some examples of SET-STRUC
, while trying to Fill in some Set-struc-intersect examples)
(We have no examples for SET-STRUC yet)
Beginning 2nd cycle.
Creating new Being, similar to SET-STRUC, named INT-SET-STRUC, but
restricted so as to make it more interesting.
An INT-SET-STRUC is any SET-STRUC for which (Each pair of
elements satisfies the same interesting predicate P (for some P)).
Filled in examples of SET-STRUC.
0 examples existed originally on SET-STRUC.
11 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(CLASS)
(CLASS DOUG CORDELL BRUCE)
(CLASS R0-7 R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7)
(CLASS A)
(CLASS B)
(CLASS A B)
(CLASS 0 D F I M)
After eliminating duplicate and already-known entries, AM finds that.
only 7 new, distinct examples of SET-STRUC had to be added.
Do-thresh raised from 332 to 346 because this last Cand succeeded, so
.ONCE TURN ON "→"
we raise our hopes-- and our standards-- temporarily.→⊗8←αααα⊗*⊗2(β)⊗3
This Cand used 23.743 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Int-set-struc
2: Fill in some examples of Coalesce
3: Check all examples of Set-struc
I choose first Cand. OK? ⊗4yes.⊗*
The reason for considering this Cand is: (Any example of
INT-SET-STRUC is automatically an interesting example of SET-STRUC)
Beginning 3rd cycle.
Won't try to create a restricted interesting version of INT-SET-STRUC.
Filled in examples of INT-SET-STRUC.
0 examples existed originally on INT-SET-STRUC.
13 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(CLASS)
(CLASS A)
(CLASS B)
After eliminating duplicate and already-known entries, AM finds that.
only 3 new, distinct examples of INT-SET-STRUC had to be added.
.ONCE TURN ON "→"
Do-thresh raised from 346 to 358.→⊗8←αααα⊗*⊗2(ε)⊗3
This Cand used 11.881 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Obj-equal
2: Check all examples of Int-set-struc
3: Check all examples of Set-struc
I choose first Cand. OK? ⊗4yes.⊗*
The reason for considering this Cand is: (We have no examples
for OBJ-EQUAL yet)
Beginning 4th cycle.
Record of attempts to find examples:-----------------------------------
An ex ( sought) is: ((CLASS A),(CLASS A) → T) +------------------
----+---------------------------------------+---------------------------
--------+----------+------+---
Found 6 examples ( and 151 non-exs), in 11.644 secs.
Ratio of exs to non-exs is too low ( 6 / 151); Exs are too sparse.
AM will sometime try to generalize OBJ-EQUAL.
Won't try to create a restricted interesting version of OBJ-EQUAL.
Filled in examples of OBJ-EQUAL.
0 examples existed originally on OBJ-EQUAL.
6 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((CLASS A) (CLASS A) → T)
((CLASS O D F I M) (CLASS O D F I M) → T)
(FALSE FALSE → T)
After eliminating duplicate and already-known entries, AM finds that.
only 3 new, distinct examples of OBJ-EQUAL had to be added.
Do-thresh raised from 358 to 359.
This Cand used 17.886 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 359 to 239
Must find new candidates and merge them into CANDS.
The top 3 Cands are:
1: Fill in some examples of Set-struc-intersect
2: Check all examples of Int-set-struc
3: Fill in some generalizations of Obj-equal
I choose first Cand. OK? ⊗4yes.⊗*
The reason for considering this Cand is: (We have no examples
for SET-STRUC-INTERSECT yet)
AM recently tried this same Cand, so let's skip it now.
The top 3 Cands are:
1: Check all examples of Int-set-struc
2: Fill in some generalizations of Obj-equal
3: Check all examples of Set-struc
I choose first Cand. OK? ⊗4yes.⊗*
The reason for considering this Cand is: (Some new , unchecked
examples of INT-SET-STRUC have recently been added)
Beginning 5th cycle.
AM is forgetting the entire SUGG facet of the INT-SET-STRUC concept.
Because: (No sense using this suggestion more than once).
Checked examples of INT-SET-STRUC and all entries were confirmed
This Cand used 11.362 cpu seconds.
The top 3 Cands are:
1: Check all examples of Set-struc
2: Fill in some generalizations of Obj-equal
3: Fill in some examples of Coalesce
I choose first Cand. OK? ⊗4yes.⊗*
The reason for considering this Cand is: (Some new , unchecked
examples of SET-STRUC have recently been added)
Beginning 6th cycle.
Based on empirical experiments, AM believes that SET-STRUC may really
be no more specialized than UNORD-OBJ.
Closer inspection reveals that the evidence for this was quite flimsy.
AM will wait until some examples of any of these have been found: (
BAG-STRUC), and then see if they truly also are SET-STRUC's.
Based on empirical experiments, AM believes that SET-STRUC may really
be no more specialized than NONMULT-STRUC.
Closer inspection reveals that the evidence for this was quite flimsy.
AM will wait until some examples of any of these have been found: (
OSET-STRUC), and then see if they truly also are SET-STRUC's.
Checked examples of SET-STRUC.
5 entries were there initially.
1 small modifications had to be made.
5 entries are present now.
This Cand used 8.008 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Bag-struc
2: Fill in some examples of Oset-struc
3: Fill in some generalizations of Obj-equal
I choose first Cand. OK? ⊗4yes.⊗*
The reason for considering this Cand is: (We have no examples
for BAG-STRUC yet)
Beginning 7th cycle.
Filled in examples of BAG-STRUC.
0 examples existed originally on BAG-STRUC.
19 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(BAG)
(BAG A)
(BAG B)
(BAG A B)
(BAG A A)
(BAG A A B)
(BAG 0 D F I M)
(BAG A B (BAG B) (CLASS))
(BAG BRUCE CORDELL DOUG)
(BAG R0-7 R1-7 R2-7 R3-7 R4-7 R5-7 R6-7 R7-7)
After eliminating duplicate and already-known entries, AM finds that.
only 10 new, distinct examples of BAG-STRUC had to be added.
XEQ-CAND
Do-thresh raised from 239 to 264.
This Cand used 17.692 cpu seconds.
The top 3 Cands are:
1: Fill in some generalizations of Obj-equal
2: Fill in some examples of Oset-struc
3: Fill in some examples of Coalesce
I choose first Cand. OK? ⊗4yes.⊗*
The reason is: (The ratio of examples to non-examples of
OBJ-EQUAL is too low ; OBJ-EQUAL is too specialized , too narrow)
Beginning 8th cycle.
Considering genlizing a recursive defn of OBJ-EQUAL
Will try to remove a conjunct.
2 possible conjuncts to choose from.
AM generalizes OBJ-EQUAL into the new concept GENL-OBJ-EQUAL, by
not recursing on the CAR of each arg.
i.e., GENL-OBJ-EQUAL will not have a recursive check
like this one, which is present in OBJ-EQUAL:
APPLYB
(QUOTE OBJ-EQUAL)
(QUOTE DEFN)
(CAR BA1)
(CAR BA2)
AM generalizes OBJ-EQUAL into the new concept GENL-OBJ-EQUAL-1,
by not recursing on the CDR of each arg.
i.e., GENL-OBJ-EQUAL-1 will not have a recursive check
like this one, which is present in OBJ-EQUAL:
APPLYB
(QUOTE OBJ-EQUAL)
(QUOTE DEFN)
(CDR BA1)
(CDR BA2)
If any of (GENL-OBJ-EQUAL GENL-OBJ-EQUAL-1) ever seems to be too
specialized, AM will consider disjoining it with other members of that
set.
Filled in generalizations of OBJ-EQUAL.
0 generalizations existed originally on OBJ-EQUAL.
2 potential new entries were just proposed.
Eliminating duplicates, the newly constructed generalizations are:
GENL-OBJ-EQUAL
GENL-OBJ-EQUAL-1
After eliminating duplicate and already-known entries, AM finds that.
all 2 new, distinct generalizations of OBJ-EQUAL had to be added.
Do-thresh raised from 264 to 335.
This Cand used 6.667 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Genl-obj-equal-1
2: Fill in some examples of Genl-obj-equal
3: Fill in some examplls of Oset-struc
I choose first Cand. OK? ⊗4yes.⊗*
The reason is: (The generalization GENL-OBJ-EQUAL-1 of OBJ-EQUAL
is relatively new and has no exs of its own yet , excepting those
of OBJ-EQUAL)
Beginning 9th cycle.
?: ⊗4N⊗*
Rename which existing concept? ⊗4GENL-OBJ-EQUAL⊗*
What is its new name? ⊗4SAME-SIZE⊗*
Done.
Record of attempts to find examples:
-
An ex ( sought) is: ((VECTOR BAG) (VECTOR B (BAG B) (CLASS) A))+-----++
-+---+-------++-+--++-+------------++-------+--+--------+-----------+-+-
---------++--+--------------------++------+-+----+
Found 26 examples ( and 105 non-exs), in 8.037 secs.
A nice ratio of exs/non-exs was encountered for GENL-OBJ-EQUAL-1
Won't try to create a restricted interesting version of
GENL-OBJ-EQUAL-1.
Filled in examples of GENL-OBJ-EQUAL-1.
0 examples existed originally on GENL-OBJ-EQUAL-1.
26 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((VECTOR BAG) (VECTOR B (BAG B) (CLASS) A) → T)
((OSET 0 D F I M) (OSET 0 D F I M) → T)
((BAG) (BAG DON ED) → T)
((OSET D M I F 0) (OSET D M I F 0) → T)
((PAIR DOUG BRUCE) (PAIR DOUG BRUCE) → T)
((VECTOR BAG) (VECTOR D M I F 0) → T)
((VECTOR B) (VECTOR D M I F 0) → T)
((BAG B) (BAG B) → T)
((VECTOR D M I F 0) (VECTOR A A B) → T)
((BAG A) (BAG A B) → T)
((VECTOR) (VECTOR B (BAG B) (CLASS) A) → T)
((OSET BRUCE DON) (OSET B A) → T)
((PAIR COMPOSE-EXS COMPOSE-EXS) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) → T)
((OSET R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6) (OSET 0 D F I M) → T)
((OSET A B (BAG B) (CLASS)) (OSET B (BAG B) (CLASS) A) → T)
((OSET 0 D F I M) (OSET B) → T)
((VECTOR A A) (VECTOR A B) → T)
((OSET DON ED) (OSET BAG) → T)
((BAG A A B) (BAG) → T)
((OSET B) (OSET BRUCE DON) → T)
((CLASS DON ED) (CLASS A) → T)
((PAIR LIST-STRUC-INSERT CANONIZE) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) → T)
((VECTOR) (VECTOR BAG) → T)
((OSET A) (OSET D M I F 0) → T)
((VECTOR BAG) (VECTOR BAG) → T)
After eliminating duplicate and already-known entries, AM finds that.
only 25 new, distinct examples of GENL-OBJ-EQUAL-1 had to be added.
Do-thresh raised from 335 to 367.
This Cand used 29.095 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Same-size
2: Check all examples of Genl-obj-equal-1
3: Fill in some examples of Coalesce
I choose first Cand. OK? ⊗4yes.⊗*
The 2 reasons are:
(Interestingness of SAME-SIZE has changed recently)
(The generalization SAME-SIZE of OBJ-EQUAL is relatively new
and has no exs of its own yet , excepting those of OBJ-EQUAL)
Beginning 10th cycle.
Record of attempts to find examples:
-
An ex ( sought) is: ((VECTOR A) (OSET B))+---+--+--------+----++++-----
----+-+---+-+-----+-------+--+-+---+-+----------+-+----------+---+-----+
----+---+---------------+
Found 26 examples ( and 102 non-exs), in 8.032 secs.
A nice ratio of exs/non-exs was encountered for SAME-SIZE
Won't try to create a restricted interesting version of SAME-SIZE.
Filled in examples of SAME-SIZE.
0 examples existed originally on SAME-SIZE.
36 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((OSET 0 D F I M) (OSET 0 D F I M) → T)
((OSET D M I F 0) (OSET D M I F 0) → T)
((PAIR DOUG BRUCE) (PAIR DOUG BRUCE) → T)
((BAG B) (BAG B) → T)
((OSET BRUCE DON) (OSET B A) → T)
((PAIR COMPOSE-EXS COMPOSE-EXS) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) → T)
((OSET A B (BAG B) (CLASS)) (OSET B (BAG B) (CLASS) A) → T)
((VECTOR A A) (VECTOR A B) → T)
((PAIR LIST-STRUC-INSERT CANONIZE) (PAIR LIST-STRUC-INTERSECT
ANYB-SPEC) → T)
((VECTOR BAG) (VECTOR BAG) → T)
((VECTOR A) (OSET B) → T)
((BAG A B) (OSET B A) → T)
((CLASS 0 D F I M) (BAG 0 D F I M) → T)
((VECTOR B) (BAG A) → T)
((PAIR LIST-STRUC-INTERSECT ANYB-SPEC) (PAIR DOUG BRUCE) → T)
((OSET DON ED) (PAIR LIST-STRUC-INTERSECT ANYB-SPEC) → T)
((BAG 0 D F I M) (VECTOR D M I F 0) → T)
((VECTOR B) (BAG B) → T)
((OSET BAG) (OSET A) → T)
((VECTOR A A) (BAG A A) → T)
((CLASS A) (VECTOR BAG) → T)
((CLASS A B) (OSET A B) → T)
((PAIR COMPOSE-EXS COMPOSE-EXS) (OSET DON ED) → T)
((VECTOR A) (OSET A) → T)
((OSET BAG) (CLASS A) → T)
((OSET A) (CLASS A) → T)
((OSET B) (OSET A) → T)
((BAG 0 D F I M) (OSET 0 D F I M) → T)
((OSET DON ED) (OSET ED CORDELL) → T)
((OSET ED CORDELL) (OSET B A) → T)
((OSET A) (BAG B) → T)
((OSET B A) (OSET A B) → T)
((VECTOR B A) (OSET ED CORDELL) → T)
((OSET A) (VECTOR BAG) → T)
((OSET B A) (OSET DON ED) → T)
After eliminating duplicate and already-known entries, AM finds that.
only 35 new, distinct examples of SAME-SIZE had to be added.
Do-thresh raised from 367 to 406.
This Cand used 21.725 cpu seconds.
The top 3 Cands are:
1: Check all examples of Same-size
2: Check all examples of Genl-obj-equal-1
3: Check all things which just barely miss being examples of
Same-size
I choose first Cand. OK? ⊗4yes.⊗*
The reason is: (Some new , unchecked examples of SAME-SIZE
have recently been added)
Beginning 11st cycle.
Checked examples of SAME-SIZE.
35 entries were there initially.
1 had to be completely discarded.
4 had to be transferred elsewhere.
30 entries are present now.
Do-thresh raised from 406 to 421.
This Cand used 6.917 cpu seconds.
The top 3 Cands are:
1: Check all examples of Genl-obj-equal-1
2: Check all things which just barely miss being examples of
Same-size
3: Fill in some examples of Coalesce
I choose first Cand. OK? ⊗4yes.⊗*
The reason is: (Some new , unchecked examples of
GENL-OBJ-EQUAL-1 have recently been added)
Beginning 12nd cycle.
Checked examples of GENL-OBJ-EQUAL-1.
25 entries were there initially.
1 had to be completely discarded.
4 had to be transferred elsewhere.
20 entries are present now.
This Cand used 4.711 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 421 to 333
Must find new candidates and merge them into CANDS.
The top 3 Cands are:
1: Canonize these 2 arguments: Genl-obj-equal-1 and Obj-equal
2: Canonize these 2 arguments: Same-size and Obj-equal
3: Fill in some examples of Coalesce
I choose first Cand. OK? ⊗4yes.⊗*
The reason is: (It would be nice to find a canonical ( with
respect to Genl-obj-equal-1 and Obj-equal ) representation C for any
Object X ; that is ,
( GENL-OBJ-EQUAL-1 x y ) iff
( OBJ-EQUAL ( C x ) ( C y ) ) .
)
Beginning 13rd cycle.
Experiments indicate that GENL-OBJ-EQUAL-1 is affected by the varying
the type of structure of its arguments.
GENL-OBJ-EQUAL-1 doesn't look at any elements of OBJECT except possibly
the car of the structure which denotes its type, so AM replaces the
tail of OBJECT by a canonical distinguished tail, say NIL.
Succeeded!
Some conjectures that AM considers believable:
OBJ-EQUAL, restricted to canonical OBJECT's, is indistinguishable
from GENL-OBJ-EQUAL-1.
There is a powerful analogy between
GENL-OBJ-EQUAL-1.................OBJ-EQUAL
OBJECT...........................CANONICAL-OBJECT
operators on and into those operators restricted to
OBJECT...........................CANONICAL-OBJECT
statements involving these.......statements involving these
Do-thresh raised from 333 to 341.
This Cand used 9.02 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Canonical-object
2: Restrict the following: Genl-obj-equal-1 Canonical-object Domain
3: Canonize these 2 arguments: Same-size and Obj-equal
I choose first Cand. OK? ⊗4yes.⊗*
The reason is: (Any example of CANONICAL-OBJECT is a canonical
example of OBJECT)
Beginning 14th cycle.
AM will now try to produce examples of CANONICAL-OBJECT by running the
following operations:
(CANONIZE-GENL-OBJ-EQUAL-1&OBJ-EQUAL).
Won't try to create a restricted interesting version of
CANONICAL-OBJECT.
Filled in examples of CANONICAL-OBJECT.
0 examples existed originally on CANONICAL-OBJECT.
165 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(VECTOR)
(BAG)
(CLASS)
(OSET)
FALSE
T
TRUE
(PAIR)
(T)
(NIL)
(TRUE)
(FALSE)
After eliminating duplicate and already-known entries, AM finds that.
only 12 new, distinct examples of CANONICAL-OBJECT had to be added.
Do-thresh raised from 341 to 391.
This Cand used 23.827 cpu seconds.
The top 3 Cands are:
1: Restrict the following: Genl-obj-equal-1 Canonical-object Domain
2: Canonize these 2 arguments: Same-size and Obj-equal
3: Fill in examples of Coalesce
I choose first Cand. OK? ⊗4yes.⊗*
The reason is: (GENL-OBJ-EQUAL-1 was one of the predicates
which defined the new concept CANONICAL-OBJECT , so it is worth
considering the restriction of GENL-OBJ-EQUAL-1 to that subset of
OBJECT 's)
Beginning 15th cycle.
Succeeded!
Do-thresh raised from 391 to 431.
This Cand used 3.562 cpu seconds.
The top 3 Cands are:
1: Canonize these 2 arguments: Same-size and Obj-equal
2: Fill in some examples of Coalesce
3: Restrict the following: Obj-equal Canonical-object Domain
I choose first Cand. OK? ⊗4yes.⊗*
The reason is: (It would be nice to find a canonical ( with
respect to Same-size and Obj-equal ) representation C for any Object
X ; that is ,
( SAME-SIZE x y ) iff
( OBJ-EQUAL ( C x ) ( C y ) ) .
)
Beginning 16th cycle.
Experiments indicate that SAME-SIZE is not affected by varying the type
of structure of its arguments.
Experiments indicate that SAME-SIZE is not affected by reordering
elements of its structural arguments.
So any canonical arguments can be Bags and Sets.
Experiments indicate that SAME-SIZE is affected by the presence of
multiple elements in its structural arguments.
So any canonical arguments can be Bags and Lists.
SAME-SIZE doesn't look at the specific elements in OBJECT, like
OBJ-EQUAL does, so AM can replace them all by a single distinguished
element, say T.
Succeeded!
Some conjectures that AM considers believable:
OBJ-EQUAL, restricted to canonical BAG-STRUC's, is indistinguishable
from SAME-SIZE.
There is a powerful analogy between
SAME-SIZE........................OBJ-EQUAL
BAG-STRUC........................CANONICAL-BAG-STRUC
operators on and into............those operators restricted to
BAG-STRUC.................. CANONICAL-BAG-STRUC
statements involving these.......statements involving these
Do-thresh raised from 431 to 457.
This Cand used 17.297 cpu seconds.
The top 3 Cands are:
1: Fill in some examples of Canonical-bag-struc
2: Restrict the following: Same-size Canonical-bag-struc Domain
3: Restrict the following: Bag-struc-join Canonical-bag-struc Domain
I choose first Cand. OK? ⊗4yes⊗*.
The reason is: (Any example of CANONICAL-BAG-STRUC is a canonical
example of BAG-STRUC)
Beginning 17th cycle.
AM will now try to produce examples of CANONICAL-BAG-STRUC by running
the following operations:
(CANONIZE-SAME-SIZE&OBJ-EQUAL).
Filled in examples of CANONICAL-BAG-STRUC.
0 examples existed originally on CANONICAL-BAG-STRUC.
211 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
(BAG)
(BAG T T)
(BAG T T T)
(BAG T)
(BAG T T T T T)
(BAG T T T T)
(BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T)
After eliminating duplicate and already-known entries, AM finds that.
only 7 new, distinct examples of CANONICAL-BAG-STRUC had to be added.
Do-thresh raised from 457 to 478.
This Cand used 35.918 cpu seconds.
The top 3 Cands are:
1: Restrict the following: Same-size Canonical-bag-struc Domain
2: Restrict the following: Bag-struc-join Canonical-bag-struc Domain
3: Restrict the following: Obj-equal Canonical-object Domain
I choose first Cand. OK? ⊗4yes⊗*.
The reason is: (SAME-SIZE was one of the predicates which defined
the new concept CANONICAL-BAG-STRUC , so it is worth considering
the restriction of SAME-SIZE to that subset of BAG-STRUC 's)
Beginning 18th cycle.
Succeeded!
Do-thresh raised from 478 to 495.
This Cand used 3.311 cpu seconds.
?: ⊗4N⊗*
Rename which existing concept? ⊗4CANONICAL-BAG-STRUC⊗*
What is its new name? ⊗4NUMBER⊗*
Done.
?: (W, I, E, M, N, ?, Q) ⊗4N⊗*
Rename which existing concept? ⊗4CANONIZE-SAME-SIZE&OBJ-EQUAL⊗*
What is its new name? ⊗4SIZE⊗*
Done.
The top 3 Cands are:
1: Check all examples of Number
2: Restrict the following: Obj-equal Canonical-object Domain
3: Check all examples of Canonical-object
I choose first Cand. OK? ⊗4yes⊗*.
The 2 reasons are:
(Interestingness of NUMBER has changed recently)
(Some new , unchecked examples of NUMBER have recently been
added)
Beginning 19th cycle.
Checked examples of NUMBER and all entries were confirmed
This Cand used 1.909 cpu seconds.
The top 3 Cands are:
1: Check all examples of Canonical-object
2: Check all things which just barely miss being examples of Number
3: Restrict the following: Bag-struc-join Number Domain
I choose first Cand. OK? ⊗4yes⊗*.
The reason is: (Some new , unchecked examples of
CANONICAL-OBJECT have recently been added)
Beginning 20th cycle.
CANONICAL-OBJECT has 7 examples which occupy 11 list cells, but is not
interesting enough to warrant taking up that much space; so about 2
will be selected at random and forgotten.
Checked examples of CANONICAL-OBJECT.
12 entries were there initially.
10 were never confirmed or rejected.
2 had to be completely discarded.
5 entries are present now.
This Cand used 16. 626 cpu seconds.
No Cand on CANDS is good enuf.
Do-thresh reduced from 495 to 340
Must find new candidates and merge them into CANDS.
The top 3 Cands are:
1: Fill in some examples of Size
2: Fill in some examples of Coalesce
3: Restrict the following: Bag-struc-join Number Domain
I choose first Cand. OK? ⊗4yes⊗*.
The reason is: (We have no examples for SIZE yet)
Beginning 21st cycle.
Record of attempts to find examples:
An ex ( sought) is: (BAG T T)++++++++++++++++++++++++++
Found 26 examples ( and 0 non-exs), in .996 secs.
A nice ratio of exs/non-exs was encountered for SIZE
Won't try to create a restricted interesting version of SIZE.
Filled in examples of SIZE.
13 examples existed originally on SIZE.
26 potential new entries were just proposed.
Eliminating duplicates, the newly constructed examples are:
((BAG T T) → (BAG T T))
((BAG T T T T T) → (BAG T T T T T))
((BAG B) → (BAG T))
((BAG A A) → (BAG T T))
((BAG T T T) → (BAG T T T))
((BAG T T T T) → (BAG T T T T))
((BAG A B) → (BAG T T))
((BAG R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6) → (BAG T T T T T T T T T T T T T T T T T T
T T T T T T T T T T T T))
((BAG A A B) → (BAG T T T))
((BAG 0 D F I M) → (BAG T T T T T))
((BAG A) → (BAG T))
((BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T T) → (BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T T))
((BAG DON ED) → (BAG T T))
((BAG A B (BAG B) → (CLASS)) (BAG T T T T))
((BAG A B) → (BAG T T))
After eliminating duplicate and already-known entries, AM finds that.
only 14 new, distinct examples of SIZE had to be added.
Do-thresh raised from 340 to 414.
This Cand used 9.2 cpu seconds.
.E